home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / vol_100 / 104_01 / c7.c < prev    next >
Encoding:
C/C++ Source or Header  |  1980-01-01  |  13.3 KB  |  589 lines
  1.  
  2. #ifndef TRUE    /* see if include needed */
  3. #include <C.DEF>
  4. #endif
  5. heir11(lval,status)
  6. int *lval;
  7. int *status;
  8. {
  9.         int k;
  10.         char *ptr;
  11.         int  lval2[lvalsize];
  12.         k=primary(lval,status);
  13.         ptr=lval[0];
  14.         blanks();
  15.         switch(ch()) {
  16.  
  17.             /* subscript varble  */
  18.             case '[' :
  19.                 gch();  /* eat '[' */
  20.                 switch(ptr[ident]) {
  21.  
  22.                     /* array of elements */
  23.                     case array :
  24.                     *status=FALSE;
  25.                     ++lval[1];
  26.                         if (const_exp(lval2) && ch()==']') {
  27.                             lval[2]=data_size(lval)*
  28.                                 lval2[0];
  29.                             needbrack("]");
  30.                             return NOTLOADED;
  31.                             }
  32.                         else {
  33.                             expression();
  34.                             size_adjust(lval);
  35.                             swap();
  36.                             address(lval,NOTLOADED);
  37.                             add_address();
  38.                             needbrack("]");
  39.                             return ADDRESS;
  40.                             }
  41.  
  42.                     /* pointer to elements */
  43.                     case pointer:
  44.                     *status=FALSE;
  45.                         if (const_exp(lval2) && ch()==']') {
  46.                         immed();
  47.                         outdec(data_size(lval)*
  48.                             lval2[0]);
  49.                         nl();
  50.                         swap();
  51.                         rvalue(lval,2);
  52.                         add_address();
  53.                             }
  54.                         else {
  55.                             expression();
  56.                             size_adjust(lval);
  57.                             swap();
  58.                             rvalue(lval,2);
  59.                             add_address();
  60.                             }
  61.                         needbrack("]");
  62.                     lval[1] += 1;
  63.                         return ADDRESS;
  64.  
  65.                     /* not a vaild ident for subscript */
  66.                     default :
  67.                         suberror(ptr);
  68.                         return LOADED;
  69.                     }
  70.  
  71.             /* a function call */
  72.             case '(' :
  73.             *status=FALSE;
  74.                 gch(); /* eat '(' */
  75.                 callfunction(lval[0]);
  76.                 return LOADED;
  77.  
  78.             /* not a subscripted or function call (not for this level */
  79.             default:
  80.                 return k;
  81.             }
  82.         }
  83.  
  84. primary(lval,status)
  85. int *lval;
  86. int *status;
  87. {
  88.         char *ptr;
  89.         char sname[namesize];
  90.         int  num[1];
  91.         int k;
  92.  
  93.         /* clear lval array for use */
  94.         lval[0]=
  95.         lval[1]=
  96.         lval[2]=0;
  97.  
  98.         if(match("(")) {
  99.             k=heir1(lval,status);
  100.             needbrack(")");
  101.             return k;
  102.             }
  103.  
  104.     *status=FALSE;
  105.         if (symname(sname)) {
  106.             if ((lval[0]=findloc(sname))) return 2;
  107.             if ((lval[0]=ptr=findglb(sname)))
  108.                 if (ptr[ident] != function) return 2;
  109.             if (ch() =='(') {
  110.                 if (!(ptr=findglb(sname)))
  111.                 if (glbptr>=endglb) {
  112.                     error("global symbol table ofverflow");
  113.                     }
  114.                 else {
  115.                     ptr=glbptr;
  116.                     glbptr+=symsiz;
  117.                     strcpy(ptr+name,sname);
  118.                     ptr[ident]=function;
  119.                     ptr[type]=cint;
  120.                     ptr[offset]=
  121.                     ptr[offset1]=
  122.                     ptr[storage]=
  123.                     ptr[indcnt]=0;
  124.                     }
  125.  
  126.                 lval[0]=ptr;
  127.                 return 2;
  128.                 }
  129.             else {
  130.                 undefine(sname);
  131.                 return 0;
  132.                 }
  133.             }
  134.         if (constant(num)) {
  135.             return 0;
  136.             }
  137.         else {
  138.             error("invalid expression");
  139.             junk();
  140.             return 0;
  141.             }
  142.     }
  143.  
  144. /*                            */
  145. /*      written 4/23/81 by Mike Bernson         */
  146. /*                            */
  147. size_adjust(lval)
  148. int *lval;
  149. {
  150.         int size;
  151.         size=data_size(lval);
  152.         if (size == 1) return;
  153.         if (size == 2) {
  154.             doublereg();
  155.             }
  156.         }
  157.  
  158. /*                            */
  159. /*      written 4/23/81 By Mike Bernson         */
  160. /*                            */
  161. data_size(lval)
  162. int *lval;
  163. {
  164.         char *ptr;
  165.         if (!(ptr=lval[0])) return 0;
  166.         switch(ptr[ident]) {
  167.  
  168.             /* array of elements */
  169.             case array :
  170.                 switch(ptr[type]) {
  171.  
  172.                     /* char type */
  173.                     case cchar:
  174.                         return lchar;
  175.  
  176.                     /* int type */
  177.                     case cint :
  178.                         return lint;
  179.                     }
  180.  
  181.             /* pointer to elements */
  182.             case pointer :
  183.                 if (lval[1] < ptr[indcnt] && ptr[indcnt] > 1)
  184.                     return lpoint;
  185.                 else switch(ptr[type]) {
  186.  
  187.                     /* type char */
  188.                     case cchar :
  189.                         return lchar;
  190.  
  191.                     /* type int */
  192.                     case cint:
  193.                         return lint;
  194.  
  195.                     }
  196.         /* just a plain variable */
  197.         case variable :
  198.             return 1;
  199.             }
  200.         }
  201. /*                            */
  202. /*      written 4/23/81 By Mike Bernson         */
  203. /*                            */
  204. address(lval,k)
  205. int *lval;
  206. {
  207.         char *ptr;
  208.         if (!(ptr=lval[0]) || k != NOTLOADED) return;
  209.         switch(ptr[storage]) {
  210.  
  211.             /* global symbol */
  212.             case statik :
  213.                 immed();
  214.                 outstr(ptr+name);
  215.                 if (lval[2]) {
  216.                     outstr("+");
  217.                     outdec(lval[2]);
  218.                     }
  219.                 nl();
  220.                 break;
  221.  
  222.             /* local symbol */
  223.             case stkloc :
  224.             case stkarg :
  225.                 immed();
  226.                 outdec((ptr[offset]+ptr[offset1]*256+lval[2])-sp);
  227.                 nl();
  228.                 ot("dad\tsp");
  229.                 nl();
  230.                 break;
  231.  
  232.             }
  233.         }
  234. /*                        */
  235. /*    date written 6/6/81 by Mike Bernson    */
  236. /*                        */
  237. /*    check to see if static load or store    */
  238. /*                        */
  239. loadstatic(lval,k)
  240. int *lval;
  241. int k;
  242. {
  243.     char *ptr;
  244.  
  245.     ptr=lval[0];
  246.     if (ptr[storage] == statik && k == NOTLOADED) return TRUE;
  247.     else return FALSE;
  248.     }
  249. /*                            */
  250. /*      date written 4/30/81 By Mike Bernson    */
  251. /*                            */
  252. store(lval,k)
  253. int *lval;
  254. int k;
  255. {
  256.         char *ptr;
  257.     ptr=lval[0];
  258.         if (k==0) return;
  259.         switch(ptr[storage]) {
  260.  
  261.             /* local or arg type */
  262.             case stkloc :
  263.             case stkarg :
  264.             switch(ptr[ident]) {
  265.  
  266.                 /* ident =array */
  267.                 case array:
  268.                     if (lval[1] == ptr[indcnt])
  269.                     if (k==ADDRESS) putstk(ptr[type]);
  270.                     else putmem_stack(lval,ptr[type]);
  271.                     break;
  272.  
  273.                 /* ident is an pointer */
  274.                 case pointer:
  275.                     if (lval[1] == ptr[indcnt])
  276.                     if (k==ADDRESS) putstk(ptr[type]);
  277.                     else putmem_stack(lval,ptr[type]);
  278.                     else    if (k==ADDRESS) putstk(cint);
  279.                     else putmem_stack(lval,cint);
  280.                     break;
  281.  
  282.                 /* ident is a variable */
  283.                 case variable :
  284.                     if (k==ADDRESS) putstk(ptr[type]);
  285.                 else putmem_stack(lval,ptr[type]);
  286.                     break;
  287.                 }
  288.                 break;
  289.  
  290.             /* static varbles */
  291.             case statik :
  292.                 switch(ptr[ident]) {
  293.  
  294.                 /* array */
  295.                 case array :
  296.                     if (lval[1] == ptr[indcnt])
  297.                         if (k==1) putstk(ptr[type]);
  298.                         else putmem(ptr+name,ptr[type],
  299.                             lval[2]);
  300.                     break;
  301.  
  302.                 /* pointer */
  303.                 case pointer:
  304.                     if (lval[1] == ptr[indcnt])
  305.                         if (k==1) putstk(ptr[type]);
  306.                         else putmem(ptr+name,ptr[type],lval[1]);
  307.                     else
  308.                         if (k==1) putstk(cint);
  309.                         else putmem(ptr+name,cint,0);
  310.                     break;
  311.  
  312.                 /* variable */
  313.                 case variable :
  314.                     if (k==1) putstk(ptr[type]);
  315.                     else putmem(ptr+name,ptr[type],0);
  316.                     break;
  317.                 }
  318.             }
  319.         }
  320. /*                            */
  321. /*      written 4/24/81 By Mike Bernson         */
  322. /*                            */
  323. rvalue(lval,k)
  324. int *lval;
  325. int k;
  326. {
  327.         char *ptr;
  328.         ptr=lval[0];
  329.         if (k==0) return;
  330.         switch(ptr[storage]) {
  331.  
  332.             /* local or arg type */
  333.             case stkloc :
  334.             case stkarg :
  335.             switch(ptr[ident]) {
  336.  
  337.                 /* ident =array */
  338.                 case array:
  339.                     if (lval[1] == ptr[indcnt])
  340.                     if (k==ADDRESS) indirect(ptr[type]);
  341.                     else getmem_stack(lval,ptr[type]);
  342.                 else     address(lval,k);
  343.                     break;
  344.  
  345.                 /* ident is an pointer */
  346.                 case pointer:
  347.                     if (lval[1] == ptr[indcnt])
  348.                     if (k==ADDRESS) indirect(ptr[type]);
  349.                     else getmem_stack(lval,ptr[type]);
  350.                     else    if (k==ADDRESS) indirect(cint);
  351.                     else getmem_stack(lval,cint);
  352.                     break;
  353.  
  354.                 /* ident is a variable */
  355.                 case variable :
  356.                     if (k==ADDRESS) indirect(ptr[type]);
  357.                 else getmem_stack(lval,ptr[type]);
  358.                     break;
  359.                 }
  360.                 break;
  361.  
  362.             /* static varbles */
  363.             case statik :
  364.                 switch(ptr[ident]) {
  365.  
  366.                 /* array */
  367.                 case array :
  368.                     if (lval[1] == ptr[indcnt])
  369.                         if (k==1) indirect(ptr[type]);
  370.                         else getmem(ptr+name,ptr[type],
  371.                             lval[2]);
  372.                     else
  373.                         if (k==1) indirect(ptr[type]);
  374.                         else address(lval,k);
  375.                     break;
  376.  
  377.                 /* pointer */
  378.                 case pointer:
  379.                     if (lval[1] == ptr[indcnt])
  380.                         if (k==1) indirect(ptr[type]);
  381.                         else getmem(ptr+name,ptr[type],lval[2]);
  382.                     else
  383.                         if (k==1) indirect(cint);
  384.                         else getmem(ptr+name,cint,0);
  385.                     break;
  386.  
  387.                 /* variable */
  388.                 case variable :
  389.                     if (k==1) indirect(ptr[type]);
  390.                     else getmem(ptr+name,ptr[type],0);
  391.                     break;
  392.                 }
  393.             }
  394.         }
  395. equal_exp(lval,k)
  396. int *lval;
  397. int k;
  398. {
  399.         char *ptr;
  400.         int  lval2[lvalsize];
  401.     int status;
  402.  
  403.         ptr=lval[0];
  404.  
  405.         /* check to see if vaild lval */
  406.         if ((ptr[ident]==array && ptr[indcnt] != lval[1]) ||
  407.             k==0 || lval[0] == 0) {
  408.             needlval();
  409.             return;
  410.             }
  411.         address(lval,k);
  412.         push();
  413.         rvalue(lval,1);
  414.     push();
  415.         rvalue(lval2,heir1(lval2,&status));
  416.         }
  417.  
  418.  
  419. /*                            */
  420. /*      written 4/9/81 By Mike Bernson          */
  421. /*                            */
  422. equal(lval,k)
  423. int lval[];
  424. int k;
  425. {
  426.         char *ptr;
  427.         int lval2[lvalsize];
  428.     int status;
  429.  
  430.         ptr=lval[0];
  431.  
  432.         /* check to see that is expresstion is array must be element */
  433.         if (ptr[ident] == array && ptr[indcnt] != lval[1]) {
  434.                 needlval();
  435.                 return;
  436.                 }
  437.         switch(k) {
  438.  
  439.             /* data is a constant or value */
  440.             case 0 :
  441.                 needlval();
  442.                 break;
  443.  
  444.             /* address of variable is on stack */
  445.             case 1 :
  446.                 push();
  447.                 break;
  448.  
  449.             /* nothing of variable is on stack */
  450.             case 2 :
  451.                 break;
  452.             }
  453.         rvalue(lval2,heir1(lval2,&status));
  454.         }
  455.  
  456. test(label)
  457. int label;
  458. {
  459.     int status;
  460.  
  461.         needbrack("(");
  462.         status=expression();
  463.         needbrack(")");
  464.         testjump(label,status);
  465.         }
  466. /*                        */
  467. /*      written by Mike Bernson 3/80    */
  468. /*                        */
  469. const_exp(val)
  470. int val[];
  471. {
  472.         blanks();
  473.         if (hex(val)) return 1;
  474.         if (number(val)) return 1;
  475.         if (pstr(val)) return 1;
  476.         return 0;
  477.         }
  478. constant(val)
  479. int val[];
  480. {
  481.         if (hex(val)) immed();
  482.         else if (number(val)) immed();
  483.         else if (pstr(val)) immed();
  484.         else if (qstr(val)) {
  485.             immed();
  486.             printlabel(litlab);
  487.             outbyte('+');
  488.             }
  489.         else return 0;
  490.         outdec(val[0]);
  491.         nl();
  492.         return 1;
  493.         }
  494. hex(val)
  495. int val[];
  496. {
  497.         int check;
  498.         char look[2];
  499.         if (ch() != '0' || (nch() != 'X' && nch() != 'x'))
  500.             return 0;
  501.         gch();
  502.         gch();
  503.         look[1]=0;
  504.         look[0]=toupper(gch());
  505.         if (!(check=strpos("0123456789ABCDEF",look))) {
  506.             error("invaild hex constant");
  507.             junk();
  508.             val[0]=0;
  509.             return 1;
  510.             }
  511.         val[0]=check-1;
  512.         while(1) {
  513.             look[0]=toupper(ch());
  514.             if (!(check=strpos("0123456789ABCDEF",look)))
  515.                 return 1;
  516.             val[0]=val[0]*16+check-1;
  517.             gch();
  518.             }
  519.         }
  520. number(val)
  521. int val[];
  522. {
  523.         int k,minus;char c;
  524.         k=minus=1;
  525.         while(k) {
  526.             k=0;
  527.             if (match("+")) k=1;
  528.             if (match("-")) {
  529.               minus;
  530.                 k=1;
  531.                 }
  532.             }
  533.         if (!numeric(ch())) return 0;
  534.         while(numeric(ch())) {
  535.             c=inbyte();
  536.             k=k*10+(c-'0');
  537.             }
  538.         if (minus<0) k=k;
  539.         val[0]=k;
  540.         return 1;
  541.         }
  542. pstr(val)
  543. int val[];
  544. {
  545.         int k;
  546.         k=0;
  547.         if (!match("\'")) return 0;
  548.         while(ch() != '\'' && ch()) k=(k&255)*256 + estr();
  549.         gch();
  550.         val[0]=k;
  551.         return 1;
  552.         }
  553. qstr(val)
  554. int val[];
  555. {
  556.         char c;
  557.         if (!match("\"")) return 0;
  558.         val[0]=litptr;
  559.         while (ch() != '\"') {
  560.             if(!ch()) break;
  561.             if(litptr>=litmax) {
  562.                 error("string space exhausted");
  563.                 while(ch() !='\"' && ch()) estr();
  564.                 return 1;
  565.                 }
  566.             litq[litptr++]=estr();
  567.             }
  568.         gch();
  569.         litq[litptr++]=0;
  570.         return 1;
  571.         }
  572. estr()
  573. {
  574.         char check;
  575.         if (ch() != '\\') return gch();
  576.         gch();
  577.         switch(toupper(check=gch())) {
  578.             case 'R' : return CR;
  579.             case 'N' : return LF;
  580.             case 'B' : return BS;
  581.             case 'T': return TB;
  582.             case 'F' : return FF;
  583.             }
  584.         if (!isdigit(check)) return check;
  585.         check=check-'0';
  586.         while(isdigit(ch())) check=check*8+gch()-'0';
  587.         return check;
  588.         }
  589.